import { FileTypeManager, FileTypeConfig } from '../config/file-types.config';
import { ITypeEntity } from '@/types/modules/superType/types';

/**
 * 文件操作结果
 */
export interface FileOperationResult {
  success: boolean;
  error?: string;
  warnings?: string[];
  data?: any;
}

/**
 * 文件类型检查器
 */
export class FileTypeChecker {
  private fileTypeManager: FileTypeManager;

  constructor() {
    this.fileTypeManager = FileTypeManager.getInstance();
  }

  /**
   * 检查文件创建是否合法
   */
  // checkFileCreation(
  //   path: string,
  //   type: ITypeEntity['type'],
  //   content?: string,
  // ): FileOperationResult {
  //   const config = this.fileTypeManager.getConfig(type);

  //   if (!config) {
  //     return {
  //       success: false,
  //       error: `不支持的文件类型: ${type}`,
  //     };
  //   }

  //   // 检查路径权限
  //   const pathCheck = this.checkPathPermission(path, config);
  //   if (!pathCheck.success) {
  //     return pathCheck;
  //   }

  //   // 检查文件扩展名
  //   const extCheck = this.checkFileExtension(path, config);
  //   if (!extCheck.success) {
  //     return extCheck;
  //   }

  //   // 检查内容（如果提供）
  //   if (content !== undefined) {
  //     const contentCheck = this.checkFileContent(type, content);
  //     if (!contentCheck.success) {
  //       return contentCheck;
  //     }
  //   }

  //   return { success: true };
  // }

  /**
   * 检查文件写入是否合法
   */
  // checkFileWrite(
  //   path: string,
  //   content: string,
  //   existingType?: ITypeEntity['type'],
  // ): FileOperationResult {
  //   // 从路径推断文件类型
  //   const type = existingType || this.inferTypeFromPath(path);

  //   if (!type) {
  //     return {
  //       success: false,
  //       error: '无法确定文件类型',
  //     };
  //   }

  //   const config = this.fileTypeManager.getConfig(type);
  //   if (!config) {
  //     return {
  //       success: false,
  //       error: `不支持的文件类型: ${type}`,
  //     };
  //   }

  //   // 检查内容
  //   const contentCheck = this.checkFileContent(type, content);
  //   if (!contentCheck.success) {
  //     return contentCheck;
  //   }

  //   return { success: true };
  // }

  /**
   * 检查文件读取权限
   */
  // checkFileRead(path: string, type?: ITypeEntity['type']): FileOperationResult {
  //   const fileType = type || this.inferTypeFromPath(path);

  //   if (!fileType) {
  //     return { success: true }; // 未知类型允许读取
  //   }

  //   const config = this.fileTypeManager.getConfig(fileType);
  //   if (!config) {
  //     return { success: true }; // 未配置的类型允许读取
  //   }

  //   // 这里可以添加读取权限检查逻辑
  //   // 例如：某些敏感文件类型需要特殊权限

  //   return { success: true };
  // }

  /**
   * 检查路径权限
   */
  // private checkPathPermission(path: string, config: FileTypeConfig): FileOperationResult {
  //   const directory = nodePath.dirname(path);

  //   // 检查禁止路径
  //   if (config.forbiddenPaths?.some((forbidden) => directory.startsWith(forbidden))) {
  //     return {
  //       success: false,
  //       error: `${config.displayName} 不能在目录 ${directory} 中创建`,
  //     };
  //   }

  //   // 检查允许路径
  //   if (config.allowedPaths?.length) {
  //     const isAllowed = config.allowedPaths.some((allowed) => directory.startsWith(allowed));
  //     if (!isAllowed) {
  //       return {
  //         success: false,
  //         error: `${config.displayName} 只能在以下目录中创建: ${config.allowedPaths.join(', ')}`,
  //       };
  //     }
  //   }

  //   return { success: true };
  // }

  // /**
  //  * 检查文件扩展名
  //  */
  // private checkFileExtension(path: string, config: FileTypeConfig): FileOperationResult {
  //   const expectedExt = config.extension;
  //   const actualExt = this.getFileExtension(path);

  //   if (actualExt !== expectedExt) {
  //     return {
  //       success: false,
  //       error: `${config.displayName} 文件扩展名应为 .${expectedExt}，实际为 .${actualExt}`,
  //     };
  //   }

  //   return { success: true };
  // }

  // /**
  //  * 检查文件内容
  //  */
  // private checkFileContent(type: ITypeEntity['type'], content: string): FileOperationResult {
  //   const validation = this.fileTypeManager.validateContent(type, content);

  //   if (!validation.valid) {
  //     return {
  //       success: false,
  //       error: validation.error,
  //     };
  //   }

  //   return { success: true };
  // }

  /**
   * 从路径推断文件类型
   */
  // private inferTypeFromPath(path: string): ITypeEntity['type'] | null {
  //   const extension = this.getFileExtension(path);
  //   const config = this.fileTypeManager.getTypeByExtension(extension);
  //   return config?.type || null;
  // }

  /**
   * 获取文件扩展名
   */
  // private getFileExtension(path: string): string {
  //   const ext = nodePath.extname(path);
  //   return ext.startsWith('.') ? ext.slice(1) : ext;
  // }

  /**
   * 获取文件类型配置
   */
  getFileTypeConfig(type: ITypeEntity['type']): FileTypeConfig | undefined {
    return this.fileTypeManager.getConfig(type);
  }

  /**
   * 根据扩展名获取文件类型配置
   */
  getTypeByExtension(extension: string): FileTypeConfig | undefined {
    return this.fileTypeManager.getTypeByExtension(extension);
  }

  /**
   * 获取所有支持的文件类型
   */
  getSupportedFileTypes(): FileTypeConfig[] {
    return this.fileTypeManager.getAllTypes();
  }

  /**
   * 获取默认模板内容
   */
  getDefaultTemplate(type: ITypeEntity['type']): string {
    return this.fileTypeManager.getDefaultTemplate(type);
  }

  /**
   * 转换文件内容格式
   */
  transformContent(
    type: ITypeEntity['type'],
    content: string,
    direction: 'toSource' | 'fromSource',
  ): string {
    const config = this.fileTypeManager.getConfig(type);

    if (!config?.transformer) {
      return content;
    }

    try {
      if (direction === 'toSource' && config.transformer.toSource) {
        const data = JSON.parse(content);
        return config.transformer.toSource(data);
      } else if (direction === 'fromSource' && config.transformer.fromSource) {
        const data = config.transformer.fromSource(content);
        return JSON.stringify(data, null, 2);
      }
    } catch (error) {
      console.warn(`文件内容转换失败 (${type}):`, error);
    }

    return content;
  }

  /**
   * 检查文件是否支持版本控制
   */
  supportsVersionControl(type: ITypeEntity['type']): boolean {
    const config = this.fileTypeManager.getConfig(type);
    return config?.versionControl ?? true;
  }

  /**
   * 检查文件是否支持搜索
   */
  supportsSearch(type: ITypeEntity['type']): boolean {
    const config = this.fileTypeManager.getConfig(type);
    return config?.searchable ?? true;
  }

  /**
   * 获取文件的编辑器组件名
   */
  getEditorComponent(type: ITypeEntity['type']): string | undefined {
    const config = this.fileTypeManager.getConfig(type);
    return config?.editorComponent;
  }

  /**
   * 获取文件的语言类型（用于语法高亮）
   */
  getLanguageType(type: ITypeEntity['type']): string {
    const config = this.fileTypeManager.getConfig(type);
    return config?.language || 'text';
  }

  /**
   * 获取文件类型的图标
   */
  getFileIcon(type: ITypeEntity['type']): { color: string; svg: string } | string {
    const config = this.fileTypeManager.getConfig(type);
    return config?.icon || 'FileOutlined';
  }

  /**
   * 批量验证文件操作
   */
  // batchValidate(
  //   operations: Array<{
  //     type: 'create' | 'write' | 'read';
  //     path: string;
  //     fileType?: ITypeEntity['type'];
  //     content?: string;
  //   }>,
  // ): Array<FileOperationResult & { operation: any }> {
  //   return operations.map((operation) => {
  //     let result: FileOperationResult;

  //     switch (operation.type) {
  //       case 'create':
  //         result = this.checkFileCreation(operation.path, operation.fileType!, operation.content);
  //         break;
  //       case 'write':
  //         result = this.checkFileWrite(operation.path, operation.content!, operation.fileType);
  //         break;
  //       case 'read':
  //         result = this.checkFileRead(operation.path, operation.fileType);
  //         break;
  //       default:
  //         result = { success: false, error: '不支持的操作类型' };
  //     }

  //     return { ...result, operation };
  //   });
  // }
}

export default new FileTypeChecker();
